home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 001-025 / disk_024 / csh / comm1.c next >
C/C++ Source or Header  |  1992-05-06  |  8KB  |  398 lines
  1.  
  2. /*
  3.  * COMM1.C
  4.  *
  5.  * Matthew Dillon, 28 Apr 1986
  6.  *
  7.  * Most of the commands are in here (the variable commands are in set.c)
  8.  *
  9.  */
  10.  
  11. #include <exec/types.h>
  12. #include <exec/exec.h>
  13. #include <libraries/dos.h>
  14. #include <libraries/dosextens.h>
  15. #include <fcntl.h>
  16. #include "shell.h"
  17.  
  18. extern struct FileLock  *CreateDir(), *CurrentDir(), *ParentDir();
  19. extern struct FileLock  *Lock(), *DupLock();
  20. extern struct FileLock  *cdgo();
  21. extern char *AllocMem();
  22.  
  23. extern long disp_entry();
  24.  
  25. struct FileLock *Clock;
  26.  
  27. do_run(str)
  28. char *str;
  29. {
  30.    register int i, len;
  31.    register char *build, *ptr;
  32.    char from[128];
  33.    char to[128];
  34.  
  35.    from[127] = to[127] = '\0';
  36.    strcpy (from, "<*");
  37.    strcpy (to, ">*");
  38.    for (i = 1, len = 0; i < ac; ++i) {
  39.       ptr = (*av[i] == '>') ? to : ((*av[i] == '<') ? from : NULL);
  40.       if (ptr) {
  41.          strncpy (ptr, av[i], 126);
  42.          if (!ptr[1]) {
  43.             av[i] = "";
  44.             if (av[++i] == NULL)
  45.                goto rerr;
  46.             strncat (ptr, av[i], 125);
  47.          }
  48.          av[i] = "";
  49.          break;
  50.       }
  51.       len += strlen(av[i]) + 1;
  52.    }
  53.    len += strlen(av[0]) + strlen(from) + strlen(to) + 4;
  54.    build = malloc(len);
  55.    strcpy (build, av[0]);
  56.    strcat (build, " ");
  57.    strcat (build, from);
  58.    strcat (build, " ");
  59.    strcat (build, to);
  60.    for (i = 1; i < ac; ++i) {
  61.       if (*av[i]) {
  62.          strcat (build, " ");
  63.          strcat (build, av[i]);
  64.       }
  65.    }
  66.    i = Execute (build, 0, 0);
  67.    free (build);
  68.    return ((i) ? 1 : -1);
  69. rerr:
  70.    puts ("redirection syntax error");
  71.    return (-1);
  72. }
  73.  
  74. do_number()
  75. {
  76.    return (1);
  77. }
  78.  
  79. do_cat()
  80. {
  81.    FILE *fi;
  82.    int i;
  83.    char buf[256];
  84.  
  85.    for (i = 1; i < ac; ++i) {
  86.       if (fi = fopen (av[i], "r")) {
  87.          while (fgets (buf, 256, fi)) {
  88.             fputs (buf, stdout);
  89.             fflush (stdout);
  90.          }
  91.          fclose (fi);
  92.       } else {
  93.          perror (av[i]);
  94.       }
  95.    }
  96. }
  97.  
  98. do_dir(garbage, com)
  99. char *garbage;
  100. {
  101.    struct DPTR          *dp;
  102.    struct InfoData      *info;
  103.    char *name;
  104.    int i, stat;
  105.    long total = 0;
  106.  
  107.    if (ac == 1) {
  108.       ++ac;
  109.       av[1] = "";
  110.    }
  111.    for (i = 1; i < ac; ++i) {
  112.       if ((dp = dopen (av[i], &stat)) == NULL)
  113.          continue;
  114.       if (com < 0) {
  115.          info = (struct InfoData *)AllocMem(sizeof(struct InfoData), MEMF_PUBLIC);
  116.          if (Info (dp->lock, info)) {
  117.             int bpb = info->id_BytesPerBlock;
  118.             printf ("Unit:%2d  Errs:%3d  Bytes: %-7d Free: %-7d\n",
  119.                   info->id_UnitNumber,
  120.                   info->id_NumSoftErrors,
  121.                   bpb * info->id_NumBlocks,
  122.                   bpb * (info->id_NumBlocks - info->id_NumBlocksUsed));
  123.          } else {
  124.             perror (av[i]);
  125.          }
  126.          FreeMem (info, sizeof(*info));
  127.       } else {
  128.          if (stat) {
  129.             while (dnext (dp, &name, &stat))
  130.                total += disp_entry (dp->fib);
  131.          } else {
  132.             total += disp_entry(dp->fib);
  133.          }
  134.  
  135.       }
  136.       dclose (dp);
  137.    }
  138.    printf ("TOTAL: %ld\n", total);
  139.    return (1);
  140. }
  141.  
  142.  
  143. long
  144. disp_entry(fib)
  145. register struct FileInfoBlock *fib;
  146. {
  147.    char str[5];
  148.    register char *dirstr;
  149.  
  150.    str[4] = '\0';
  151.    str[0] = (fib->fib_Protection & FIBF_READ) ? '-' : 'r';
  152.    str[1] = (fib->fib_Protection & FIBF_WRITE) ? '-' : 'w';
  153.    str[2] = (fib->fib_Protection & FIBF_EXECUTE) ? '-' : 'x';
  154.    str[3] = (fib->fib_Protection & FIBF_DELETE) ? '-' : 'd';
  155.    dirstr = (fib->fib_DirEntryType < 0) ? "   " : "DIR";
  156.  
  157.    printf ("%s %6ld %s  %s\n", str, (long)fib->fib_Size, dirstr, fib->fib_FileName);
  158.    return ((long)fib->fib_Size);
  159. }
  160.  
  161.  
  162. do_quit()
  163. {
  164.    exit (1);
  165. }
  166.  
  167. do_echo(str)
  168. char *str;
  169. {
  170.    if (strcmp (av[1], "-n") == 0) {
  171.       fputs (next_word(next_word(str)), stdout);
  172.    } else {
  173.       puts (next_word(str));
  174.    }
  175.    fflush (stdout);
  176.    return (1);
  177. }
  178.  
  179.  
  180. do_source(str)
  181. char *str;
  182. {
  183.    register FILE *fi;
  184.    char buf[256];
  185.  
  186.    if (Src_stack == MAXSRC) {
  187.       puts ("Too many source levels");
  188.       return(-1);
  189.    }
  190.    fi = fopen (next_word(str), "r");
  191.    if (fi == NULL) {
  192.       printf ("Cannot open %s\n", str);
  193.       return(-1);
  194.    }
  195.    ++H_stack;
  196.    Src_pos[Src_stack] = 0;
  197.    Src_base[Src_stack] = fi;
  198.    ++Src_stack;
  199.    while (fgets (buf, 256, fi) != NULL) {
  200.       Src_pos[Src_stack - 1] += strlen(buf);
  201.       buf[strlen(buf) - 1] = '\0';
  202.       exec_command (buf);
  203.    }
  204.    --H_stack;
  205.    --Src_stack;
  206.    unset_level(LEVEL_LABEL + Src_stack);
  207.    fclose (fi);
  208.    return (1);
  209. }
  210.  
  211. /*
  212.  * cd.  Additionally, allow '..' to get you back one directory in the path.
  213.  */
  214.  
  215. do_cd()
  216. {
  217.    static char root[32];
  218.    register struct FileLock *lock;
  219.    register char *str, *ptr;
  220.    register int notdone;
  221.  
  222.    if (ac != 2) {
  223.       puts (root);
  224.       Clock = cdgo (root, NULL);
  225.       return (1);
  226.    }
  227.    str = av[1];
  228.    while (*str == '/') {
  229.       ++str;
  230.       if (Clock)
  231.          Clock = cdgo (NULL, Clock);
  232.    }
  233.    notdone = 1;
  234.    while (notdone) {
  235.       ptr = str;
  236.       while (*str && *str != '/' && *str != ':')
  237.          ++str;
  238.       notdone = *str;
  239.       *str++ = '\0';
  240.       if (ptr == str - 1)
  241.          continue;
  242.       if (notdone == ':') {
  243.          *(str-1) = notdone;
  244.          notdone = *str;
  245.          *str = '\0';
  246.          strcpy (root, ptr);
  247.          Clock = cdgo (root, NULL);
  248.          *str = notdone;
  249.       } else
  250.       if (strcmp (ptr, "..") == 0) {
  251.          if (Clock)
  252.             Clock = cdgo (NULL, Clock);
  253.       } else {
  254.          if ((lock = cdgo (ptr, NULL)) == NULL)
  255.             puts ("not found");
  256.          else
  257.             Clock = lock;
  258.       }
  259.    }
  260.    return (1);
  261. }
  262.  
  263.  
  264. struct FileLock *
  265. cdgo(ptr, lock)
  266. char *ptr;
  267. struct FileLock *lock;
  268. {
  269.    struct FileLock *newlock, *oldlock;
  270.  
  271.    if (lock)
  272.       newlock = ParentDir (lock);
  273.    else
  274.       newlock = Lock (ptr, ACCESS_READ);
  275.    if (newlock) {
  276.       if (oldlock = CurrentDir (newlock))
  277.          UnLock (oldlock);
  278.    }
  279.    return (newlock);
  280. }
  281.  
  282.  
  283. do_mkdir()
  284. {
  285.    register int i;
  286.    register struct FileLock *lock;
  287.  
  288.    for (i = 1; i < ac; ++i) {
  289.       if (lock = CreateDir (av[i])) {
  290.          UnLock (lock);
  291.          continue;
  292.       }
  293.       perror (av[i]);
  294.    }
  295.    return (1);
  296. }
  297.  
  298. do_mv()
  299. {
  300.    if (Rename (av[1], av[2]))
  301.       return (1);
  302.    perror (NULL);
  303.    return (-1);
  304. }
  305.  
  306. do_rm()
  307. {
  308.    register int i;
  309.  
  310.    for (i = 1; i < ac; ++i) {
  311.       if (!DeleteFile(av[i]))
  312.          perror (av[i]);
  313.    }
  314.    return (1);
  315. }
  316.  
  317.  
  318. do_history()
  319. {
  320.    register struct HIST *hist;
  321.    register int i = H_tail_base;
  322.  
  323.    for (hist = H_tail; hist; hist = hist->prev) {
  324.       printf ("%3d %s\n", i, hist->line);
  325.       ++i;
  326.    }
  327.    return (1);
  328. }
  329.  
  330. do_mem()
  331. {
  332.    long cfree, ffree;
  333.    extern long AvailMem();
  334.  
  335.    Forbid();
  336.    cfree = AvailMem (MEMF_CHIP);
  337.    ffree = AvailMem (MEMF_FAST);
  338.    Permit();
  339.  
  340.    if (ffree)
  341.       printf ("FAST memory:%10ld\n", ffree);
  342.    printf ("CHIP memory:%10ld\n", cfree);
  343.    printf ("Total -----:%5ld K\n", (ffree + cfree)/1024L);
  344. }
  345.  
  346. /*
  347.  * foreach var_name  ( str str str str... str ) commands
  348.  * spacing is important (unfortunetly)
  349.  *
  350.  * ac=0    1 2 3 4 5 6 7
  351.  * foreach i ( a b c ) echo $i
  352.  * foreach i ( *.c )   "echo -n "file ->";echo $i"
  353.  */
  354.  
  355. do_foreach()
  356. {
  357.    register int i, cstart, cend, old;
  358.    register char *cstr, *vname, *ptr, *scr, *args;
  359.  
  360.    cstart = i = (*av[2] == '(') ? 3 : 2;
  361.    while (i < ac) {
  362.       if (*av[i] == ')')
  363.          break;
  364.       ++i;
  365.    }
  366.    if (i == ac) {
  367.       puts ("')' expected");
  368.       return (-1);
  369.    }
  370.    ++H_stack;
  371.    cend = i;
  372.    vname = strcpy(malloc(strlen(av[1])+1), av[1]);
  373.    cstr = compile_av (av, cend + 1, ac);
  374.    ptr = args = compile_av (av, cstart, cend);
  375.    while (*ptr) {
  376.       while (*ptr == ' ' || *ptr == 9)
  377.          ++ptr;
  378.       scr = ptr;
  379.       if (*scr == '\0')
  380.          break;
  381.       while (*ptr && *ptr != ' ' && *ptr != 9)
  382.          ++ptr;
  383.       old = *ptr;
  384.       *ptr = '\0';
  385.       set_var (LEVEL_SET, vname, scr);
  386.       exec_command (cstr);
  387.       *ptr = old;
  388.    }
  389.    --H_stack;
  390.    free (args);
  391.    free (cstr);
  392.    unset_var (LEVEL_SET, vname);
  393.    free (vname);
  394.    return (1);
  395. }
  396.  
  397.  
  398.